Dasturchi uchun Python dizayn patternlari bo'yicha qo'llanma: Singleton, Factory va Observer

Dasturiy ta'minot muhandisligi olamida shunchaki ishlaydigan kod yozish bu faqat birinchi qadamdir. Masshtablanuvchan, qo'llab-quvvatlanadigan va moslashuvchan dasturiy ta'minot yaratish professional dasturchining o'ziga xos belgisidir. Aynan shu yerda dizayn patternlari yordamga keladi. Ular maxsus algoritmlar yoki kutubxonalar emas, balki dasturiy ta'minot dizaynidagi umumiy muammolarni hal qilish uchun yuqori darajadagi, tilga bog'liq bo'lmagan chizmalardir.

Ushbu keng qamrovli qo'llanma sizni Python'da amalga oshirilgan eng fundamental va keng qo'llaniladigan uchta dizayn patterni: Singleton, Factory va Observer bilan chuqur tanishtiradi. Biz ularning nima ekanligini, nima uchun foydali ekanligini va ularni Python loyihalaringizda qanday qilib samarali amalga oshirishni o'rganamiz.

Dizayn Patternlari Nima va Nima Uchun Ular Muhim?

"To'rtlik to'dasi" (GoF) tomonidan o'zlarining mashhur "Design Patterns: Elements of Reusable Object-Oriented Software" kitobida ilk bor konsepsiyalangan dizayn patternlari takrorlanuvchi dizayn muammolarining isbotlangan yechimlaridir. Ular dasturchilar uchun umumiy lug'atni taqdim etib, jamoalarga murakkab arxitektura yechimlarini yanada samaraliroq muhokama qilish imkonini beradi.

Dizayn patternlaridan foydalanish quyidagilarga olib keladi:

• Qayta foydalanish imkoniyatining ortishi: Yaxshi loyihalangan komponentlar turli loyihalarda qayta ishlatilishi mumkin.
• Qo'llab-quvvatlashning yaxshilanishi: Kod tartibliroq, tushunish osonroq bo'ladi va o'zgartirishlar kiritilganda xatolarga kamroq moyil bo'ladi.
• Masshtablanuvchanlikning oshishi: Arxitektura moslashuvchanroq bo'lib, tizimni to'liq qayta yozishni talab qilmasdan o'sishiga imkon beradi.
• Kuchsiz bog'liqlik: Komponentlar bir-biriga kamroq bog'liq bo'lib, modullikni va mustaqil rivojlanishni rag'batlantiradi.

Keling, tadqiqotimizni obyekt yaratilishini nazorat qiluvchi yaratuvchi pattern: Singleton'dan boshlaymiz.

Singleton Patterni: Barchasini Boshqarish Uchun Yagona Instansiya

Singleton Patterni Nima?

Singleton patterni bu bir sinfning faqat bitta instansiyasiga ega bo'lishini ta'minlaydigan va unga yagona, global kirish nuqtasini taqdim etadigan yaratuvchi patterndir. Tizim bo'ylab konfiguratsiya menejeri, logging xizmati yoki ma'lumotlar bazasiga ulanishlar puli haqida o'ylang. Siz bu komponentlarning bir nechta, mustaqil instansiyalari aylanib yurishini xohlamaysiz; sizga yagona, ishonchli manba kerak.

Singleton'ning asosiy tamoyillari:

1. Yagona Instansiya: Sinf ilovaning hayotiy sikli davomida faqat bir marta yaratilishi mumkin.
2. Global Kirish: Kod bazasining istalgan joyidan ushbu noyob instansiyaga kirish mexanizmi mavjud.

Qachon Foydalanish Kerak (Va Qachon Undan Qochish Kerak)

Singleton patterni kuchli, lekin ko'pincha ortiqcha ishlatiladi. Uning to'g'ri qo'llanilish holatlarini va jiddiy kamchiliklarini tushunish juda muhim.

Yaxshi Qo'llash Holatlari:

• Logging: Yagona logging obyekti loglarni boshqarishni markazlashtirishi mumkin, bu esa ilovaning barcha qismlari bir xil faylga yoki xizmatga muvofiqlashtirilgan tarzda yozishini ta'minlaydi.
• Konfiguratsiyani Boshqarish: Ilovaning konfiguratsiya sozlamalari (masalan, API kalitlari, funksiya bayroqlari) bir marta yuklanishi va yagona haqiqat manbasidan global miqyosda foydalanilishi kerak.
• Ma'lumotlar Bazasiga Ulanish Pullari: Ma'lumotlar bazasiga ulanishlar pulini boshqarish resurs talab qiladigan vazifadir. Singleton pulning bir marta yaratilishini va ilova bo'ylab samarali taqsimlanishini ta'minlay oladi.
• Uskuna Interfeysiga Kirish: Printer yoki maxsus sensor kabi yagona uskuna bilan ishlaganda, singleton bir vaqtning o'zida bir nechta kirish urinishlaridan kelib chiqadigan ziddiyatlarning oldini oladi.

Singleton'larning Xavflari (Anti-Pattern Nuqtai Nazari):

Foydali bo'lishiga qaramay, Singleton ko'pincha anti-pattern deb hisoblanadi, chunki u:

• Yagona Mas'uliyat Tamoyilini Buzadi: Singleton sinfi ham o'zining asosiy mantig'i uchun, ham o'z hayotiy siklini boshqarish uchun (yagona instansiyani ta'minlash) mas'uldir.
• Global Holatni Joriy Qiladi: Global holat kodni tushunish va diskretlashni qiyinlashtiradi. Tizimning bir qismidagi o'zgarish boshqa qismida kutilmagan nojo'ya ta'sirlarga olib kelishi mumkin.
• Testlashni Qiyinlashtiradi: Global singleton'ga tayanadigan komponentlar unga qattiq bog'langan bo'ladi. Bu birlik testlashni qiyinlashtiradi, chunki siz izolyatsiya qilingan testlash uchun singleton'ni osonlikcha mock yoki stub bilan almashtira olmaysiz.

Ekspert Maslahati: Singleton'dan foydalanishdan oldin, Bog'liqlik Inyeksiyasi (Dependency Injection) muammoingizni yanada oqilona hal qila oladimi yoki yo'qligini ko'rib chiqing. Obyektning yagona instansiyasini (masalan, konfiguratsiya obyekti) unga muhtoj bo'lgan sinflarga uzatish global holatning kamchiliklarisiz bir xil maqsadga erishishi mumkin.

Python'da Singleton'ni Amalga Oshirish

Python Singleton patternini amalga oshirishning bir necha usullarini taklif qiladi, ularning har biri o'zining afzalliklari va kamchiliklariga ega. Python'ning qiziqarli jihatlaridan biri shundaki, uning modul tizimi o'z-o'zidan singleton kabi ishlaydi. Siz modulni import qilganingizda, Python uni faqat bir marta yuklaydi va ishga tushiradi. Xuddi shu modulni kodingizning turli qismlarida keyingi import qilishlar bir xil modul obyektiga havolani qaytaradi.

Keling, sinfga asoslangan aniqroq amaliyotlarni ko'rib chiqaylik.

1-Amaliyot: Metaklassdan Foydalanish

Metaklassdan foydalanish ko'pincha singleton'ni amalga oshirishning eng mustahkam va "Pythonic" usuli hisoblanadi. Sinf obyektning xatti-harakatini belgilagani kabi, metaklass ham sinfning xatti-harakatini belgilaydi. Bu yerda biz sinf yaratish jarayonini to'xtatib qolishimiz mumkin.

            
class SingletonMeta(type):
    """Singleton sinfini yaratish uchun metaklass."""
    _instances = {}

    def __call__(cls, *args, **kwargs):
        # Bu usul instansiya yaratilganda chaqiriladi, masalan, MyClass()
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]

class GlobalConfig(metaclass=SingletonMeta):
    def __init__(self):
        # Bu faqat instansiya birinchi marta yaratilganda bajariladi.
        print("GlobalConfig ishga tushirilmoqda...")
        self.settings = {"api_key": "default_key", "timeout": 30}

    def get_setting(self, key):
        return self.settings.get(key)

# --- Foydalanish ---
config1 = GlobalConfig()
config2 = GlobalConfig()

print(f"config1 sozlamalari: {config1.settings}")
config1.settings["api_key"] = "new_secret_key_12345"

print(f"config2 sozlamalari: {config2.settings}") # Yangilangan kalitni ko'rsatadi

# Ularning bir xil obyekt ekanligini tekshirish
print(f"config1 va config2 bir xil instansiyami? {config1 is config2}")

            

              
                Copy
              
            
          

Ushbu misolda `SingletonMeta`ning `__call__` usuli `GlobalConfig`ning yaratilishini to'xtatadi. U `_instances` lug'atini saqlaydi va `GlobalConfig`ning faqat bitta instansiyasi yaratilishi va saqlanishini ta'minlaydi.

2-Amaliyot: Dekorator yordamida

Dekoratorlar sinfning ichki tuzilishini o'zgartirmasdan unga singleton xususiyatini qo'shishning yanada ixcham va o'qilishi oson usulini taqdim etadi.

            
def singleton(cls):
    """Sinfni Singleton'ga aylantiruvchi dekorator."""
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class DatabaseConnection:
    def __init__(self):
        print("Ma'lumotlar bazasiga ulanilmoqda...")
        # Ma'lumotlar bazasiga ulanish sozlamasini simulyatsiya qilish
        self.connection_id = id(self)

# --- Foydalanish ---
db1 = DatabaseConnection()
db2 = DatabaseConnection()

print(f"DB1 Ulanish ID'si: {db1.connection_id}")
print(f"DB2 Ulanish ID'si: {db2.connection_id}")
print(f"db1 va db2 bir xil instansiyami? {db1 is db2}")

            

              
                Copy
              
            
          

Bu yondashuv toza va singleton mantig'ini sinfning biznes mantig'idan ajratadi. Biroq, meros olish va introspeksiya bilan bog'liq ba'zi nozikliklarga ega bo'lishi mumkin.

Factory Patterni: Obyekt Yaratishni Ajratish

Keyin, biz yana bir kuchli yaratuvchi patternga o'tamiz: Factory. Har qanday Factory patternining asosiy g'oyasi obyekt yaratish jarayonini abstraktlashtirishdir. Obyektlarni konstruktor yordamida to'g'ridan-to'g'ri yaratish o'rniga (masalan, `my_obj = MyClass()`), siz factory usulini chaqirasiz. Bu sizning klient kodingizni u yaratishi kerak bo'lgan aniq sinflardan ajratadi.

Bu ajratish juda qimmatlidir. Tasavvur qiling, sizning ilovangiz ma'lumotlarni PDF, CSV va JSON kabi turli formatlarga eksport qilishni qo'llab-quvvatlaydi. Factory bo'lmasa, sizning klient kodingiz quyidagicha ko'rinishi mumkin:

            
if export_format == 'pdf':
    exporter = PDFExporter()
elif export_format == 'csv':
    exporter = CSVExporter()
else:
    exporter = JSONExporter()

exporter.export(data)

            

              
                Copy
              
            
          

Bu kod mo'rt. Agar siz yangi format qo'shsangiz (masalan, XML), siz ushbu mantiq mavjud bo'lgan har bir joyni topib, o'zgartirishingiz kerak bo'ladi. Factory bu yaratish mantig'ini markazlashtiradi.

Factory Method Patterni

Factory Method patterni obyekt yaratish uchun interfeysni belgilaydi, lekin quyi sinflarga yaratiladigan obyektlar turini o'zgartirishga imkon beradi. Bu yaratishni quyi sinflarga qoldirish haqida.

Tuzilma:

• Mahsulot (Product): Factory usuli yaratadigan obyektlar uchun interfeys (masalan, `Document`).
• Aniq Mahsulot (ConcreteProduct): Mahsulot interfeysining aniq realizatsiyalari (masalan, `PDFDocument`, `WordDocument`).
• Yaratuvchi (Creator): Factory usulini e'lon qiladigan abstrakt sinf (`create_document()`). U shuningdek factory usulidan foydalanadigan shablon usulini ham belgilashi mumkin.
• Aniq Yaratuvchi (ConcreteCreator): Muayyan Aniq Mahsulot instansiyasini qaytarish uchun factory usulini qayta yozadigan quyi sinflar (masalan, `PDFCreator` `PDFDocument`ni qaytaradi).

Amaliy Misol: Kross-platformali UI to'plami

Tasavvur qilaylik, biz turli operatsion tizimlar uchun turli xil tugmalar yaratishi kerak bo'lgan UI freymvorkini qurmoqdamiz.

            
from abc import ABC, abstractmethod

# --- Mahsulot Interfeysi va Aniq Mahsulotlar ---
class Button(ABC):
    """Mahsulot Interfeysi: Tugmalar uchun interfeysni belgilaydi."""
    @abstractmethod
    def render(self):
        pass

class WindowsButton(Button):
    """Aniq Mahsulot: Windows OS uslubidagi tugma."""
    def render(self):
        print("Windows uslubidagi tugmani render qilish.")

class MacOSButton(Button):
    """Aniq Mahsulot: macOS uslubidagi tugma."""
    def render(self):
        print("macOS uslubidagi tugmani render qilish.")

# --- Yaratuvchi (Abstrakt) va Aniq Yaratuvchilar ---
class Dialog(ABC):
    """Yaratuvchi: Factory usulini e'lon qiladi.
       U shuningdek mahsulotdan foydalanadigan biznes mantig'ini o'z ichiga oladi.
    """
    @abstractmethod
    def create_button(self) -> Button:
        """Factory usuli."""
        pass

    def show_dialog(self):
        """Aniq tugma turlaridan bexabar bo'lgan asosiy biznes mantig'i."""
        print("Umumiy dialog oynasini ko'rsatish.")
        button = self.create_button()
        button.render()

class WindowsDialog(Dialog):
    """Windows uchun Aniq Yaratuvchi."""
    def create_button(self) -> Button:
        return WindowsButton()

class MacOSDialog(Dialog):
    """macOS uchun Aniq Yaratuvchi."""
    def create_button(self) -> Button:
        return MacOSButton()

# --- Klient Kodi ---
def initialize_app(os_name: str):
    if os_name == "Windows":
        dialog = WindowsDialog()
    elif os_name == "macOS":
        dialog = MacOSDialog()
    else:
        raise ValueError(f"Qo'llab-quvvatlanmaydigan OT: {os_name}")
    
    dialog.show_dialog()

# Ilovani turli OTlarda ishga tushirishni simulyatsiya qilish
print("--- Windows'da ishga tushirish ---")
initialize_app("Windows")

print("\n--- macOS'da ishga tushirish ---")
initialize_app("macOS")

            

              
                Copy
              
            
          

`show_dialog` usuli o'zining aniq turini bilmasdan har qanday `Button` bilan qanday ishlashiga e'tibor bering. Qaysi tugmani yaratish qarori `WindowsDialog` va `MacOSDialog` quyi sinflariga topshirilgan. Bu `Dialog` sinfini yoki undan foydalanadigan klient kodini o'zgartirmasdan `LinuxDialog` qo'shishni osonlashtiradi.

Abstract Factory Patterni

Abstract Factory patterni buni bir qadam oldinga olib boradi. U bog'liq yoki o'zaro bog'liq obyektlar oilalarini ularning aniq sinflarini ko'rsatmasdan yaratish uchun interfeysni taqdim etadi. Bu xuddi boshqa factory'larni yaratadigan factory'ga o'xshaydi.

Bizning UI misolimizni davom ettiradigan bo'lsak, dialog oynasi faqat tugmaga ega emas; unda checkboxlar, matn maydonlari va boshqalar bor. Izchil ko'rinish va hissiyot (mavzu) barcha ushbu elementlarning bir xil oilaga tegishli bo'lishini talab qiladi (masalan, hammasi Windows uslubida yoki hammasi macOS uslubida).

Tuzilma:

• AbstractFactory: Abstrakt mahsulotlarni yaratish uchun factory usullari to'plamiga ega interfeys (masalan, `create_button()`, `create_checkbox()`).
• ConcreteFactory: Aniq mahsulotlar oilasini yaratish uchun AbstractFactory'ni amalga oshiradi (masalan, `LightThemeFactory`, `DarkThemeFactory`).
• AbstractProduct: Oiladagi har bir alohida mahsulot uchun interfeyslar (masalan, `Button`, `Checkbox`).
• ConcreteProduct: Har bir mahsulot oilasi uchun aniq realizatsiyalar (masalan, `LightButton`, `DarkButton`, `LightCheckbox`, `DarkCheckbox`).

Amaliy Misol: UI Mavzu Factory'si

            
from abc import ABC, abstractmethod

# --- Abstrakt Mahsulot Interfeyslari ---
class Button(ABC):
    @abstractmethod
    def paint(self):
        pass

class Checkbox(ABC):
    @abstractmethod
    def paint(self):
        pass

# --- 'Yorug'' mavzu uchun Aniq Mahsulotlar ---
class LightButton(Button):
    def paint(self):
        print("Yorug' mavzudagi tugmani chizish.")

class LightCheckbox(Checkbox):
    def paint(self):
        print("Yorug' mavzudagi checkbox'ni chizish.")

# --- 'To'q' mavzu uchun Aniq Mahsulotlar ---
class DarkButton(Button):
    def paint(self):
        print("To'q mavzudagi tugmani chizish.")

class DarkCheckbox(Checkbox):
    def paint(self):
        print("To'q mavzudagi checkbox'ni chizish.")

# --- Abstrakt Factory Interfeysi ---
class UIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass
    
    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

# --- Har bir mavzu uchun Aniq Factory'lar ---
class LightThemeFactory(UIFactory):
    def create_button(self) -> Button:
        return LightButton()
    
    def create_checkbox(self) -> Checkbox:
        return LightCheckbox()

class DarkThemeFactory(UIFactory):
    def create_button(self) -> Button:
        return DarkButton()
    
    def create_checkbox(self) -> Checkbox:
        return DarkCheckbox()

# --- Klient Kodi ---
class Application:
    def __init__(self, factory: UIFactory):
        self.factory = factory
        self.button = None
        self.checkbox = None

    def create_ui(self):
        self.button = self.factory.create_button()
        self.checkbox = self.factory.create_checkbox()

    def paint_ui(self):
        self.button.paint()
        self.checkbox.paint()

# --- Asosiy ilova mantig'i ---
def get_factory_for_theme(theme_name: str) -> UIFactory:
    if theme_name == "light":
        return LightThemeFactory()
    elif theme_name == "dark":
        return DarkThemeFactory()
    else:
        raise ValueError(f"Noma'lum mavzu: {theme_name}")

# Ilovani ma'lum bir mavzu bilan yaratish va ishga tushirish
current_theme = "dark"
ui_factory = get_factory_for_theme(current_theme)
app = Application(ui_factory)
app.create_ui()
app.paint_ui()

            

              
                Copy
              
            
          

`Application` sinfi mavzular haqida umuman bexabar. U faqat o'zining UI elementlarini olish uchun `UIFactory` kerakligini biladi. Siz `Application` klient kodiga hech qanday o'zgartirish kiritmasdan, yangi mahsulot sinflari to'plamini va yangi factory yaratish orqali butunlay yangi mavzu (masalan, `HighContrastThemeFactory`) kiritishingiz mumkin.

Observer Patterni: Obyektlarni Xabardor Qilib Turish

Nihoyat, keling, tamal toshi bo'lgan xulq-atvor patternini o'rganamiz: Observer. Bu pattern obyektlar o'rtasida bir-ko'p bog'liqlikni belgilaydi, shunda bir obyekt (subyekt) holati o'zgarganda, uning barcha bog'liqlari (kuzatuvchilar) avtomatik ravishda xabardor qilinadi va yangilanadi.

Bu pattern hodisalarga asoslangan dasturlashning asosidir. Yangiliklar lentasiga obuna bo'lish, ijtimoiy tarmoqlarda kimnidir kuzatib borish yoki aksiya narxlari haqida ogohlantirishlar olish haqida o'ylang. Har bir holatda, siz (kuzatuvchi) subyektga qiziqishingizni bildirasiz va biror yangilik sodir bo'lganda avtomatik ravishda xabardor bo'lasiz.

Asosiy Komponentlar: Subyekt va Kuzatuvchi

• Subyekt (yoki Observable): Bu qiziqish obyekti. U o'zining kuzatuvchilari ro'yxatini saqlaydi va ularni biriktirish (`subscribe`), ajratish (`unsubscribe`) va xabardor qilish uchun usullarni taqdim etadi.
• Kuzatuvchi (yoki Subscriber): Bu o'zgarishlar haqida xabardor bo'lishni xohlaydigan obyekt. U subyekt holati o'zgarganda chaqiradigan yangilash interfeysini belgilaydi.

Qachon Foydalanish Kerak

• Hodisalarni Qayta Ishlash Tizimlari: GUI to'plamlari klassik misoldir. Tugma (subyekt) bosilganda bir nechta tinglovchilarni (kuzatuvchilarni) xabardor qiladi.
• Bildirishnoma Xizmatlari: Yangiliklar veb-saytida (subyekt) yangi maqola nashr etilganda, barcha ro'yxatdan o'tgan obunachilar (kuzatuvchilar) elektron pochta yoki push-bildirishnoma oladi.
• Model-View-Controller (MVC) Arxitekturasi: Model (subyekt) har qanday ma'lumot o'zgarishlari haqida View'ni (kuzatuvchi) xabardor qiladi, shunda View yangilangan ma'lumotlarni ko'rsatish uchun o'zini qayta chizishi mumkin. Bu ma'lumotlar mantig'i va taqdimot mantig'ini alohida saqlaydi.
• Monitoring Tizimlari: Tizim salomatligi monitori (subyekt) muhim metrika (masalan, CPU yoki xotira ishlatilishi) chegaradan oshganda turli boshqaruv panellari va ogohlantirish tizimlarini (kuzatuvchilarni) xabardor qilishi mumkin.

Python'da Observer Patternini Amalga Oshirish

Bu yerda har xil turdagi obunachilarni xabardor qiladigan yangiliklar agentligining amaliy realizatsiyasi keltirilgan.

            
from abc import ABC, abstractmethod
from typing import List

# --- Kuzatuvchi Interfeysi va Aniq Kuzatuvchilar ---
class Observer(ABC):
    @abstractmethod
    def update(self, subject):
        pass

class EmailNotifier(Observer):
    def __init__(self, email_address: str):
        self.email_address = email_address

    def update(self, subject):
        print(f"{self.email_address} manziliga Email yuborilmoqda: Yangi xabar mavjud! Sarlavha: '{subject.latest_story}'")

class SMSNotifier(Observer):
    def __init__(self, phone_number: str):
        self.phone_number = phone_number

    def update(self, subject):
        print(f"{self.phone_number} raqamiga SMS yuborilmoqda: Yangiliklar ogohlantirishi: '{subject.latest_story}'")

# --- Subyekt (Observable) Sinfi ---
class NewsAgency:
    def __init__(self):
        self._observers: List[Observer] = []
        self._latest_story: str = ""

    def attach(self, observer: Observer) -> None:
        print("Yangiliklar Agentligi: Kuzatuvchi biriktirildi.")
        self._observers.append(observer)

    def detach(self, observer: Observer) -> None:
        print("Yangiliklar Agentligi: Kuzatuvchi ajratildi.")
        self._observers.remove(observer)

    def notify(self) -> None:
        print("Yangiliklar Agentligi: Kuzatuvchilar xabardor qilinmoqda...")
        for observer in self._observers:
            observer.update(self)

    @property
    def latest_story(self) -> str:
        return self._latest_story

    def add_new_story(self, story: str) -> None:
        print(f"\nYangiliklar Agentligi: Yangi xabar nashr etilmoqda: '{story}'")
        self._latest_story = story
        self.notify()

# --- Klient Kodi ---
# Subyektni yaratish
agency = NewsAgency()

# Kuzatuvchilarni yaratish
email_subscriber1 = EmailNotifier("reader1@example.com")
sms_subscriber1 = SMSNotifier("+15551234567")
email_subscriber2 = EmailNotifier("another.reader@example.com")

# Kuzatuvchilarni subyektga biriktirish
agency.attach(email_subscriber1)
agency.attach(sms_subscriber1)
agency.attach(email_subscriber2)

# Subyekt holati o'zgaradi va barcha kuzatuvchilar xabardor qilinadi
agency.add_new_story("Global Texnologiyalar Sammiti Kelasi Hafta Boshlanadi")

# Kuzatuvchini ajratish
agency.detach(email_subscriber1)

# Yana bir holat o'zgarishi sodir bo'ladi
agency.add_new_story("Qayta Tiklanuvchi Energiyada Katta Yutuq E'lon Qilindi")

            

              
                Copy
              
            
          

Ushbu misolda `NewsAgency` `EmailNotifier` yoki `SMSNotifier` haqida hech narsa bilishi shart emas. U faqat ularning `update` usuliga ega `Observer` obyektlari ekanligini biladi. Bu sizga `NewsAgency` sinfiga hech qanday o'zgartirish kiritmasdan yangi bildirishnoma turlarini (masalan, `PushNotifier`, `SlackNotifier`) qo'shish imkonini beradigan juda kuchsiz bog'langan tizimni yaratadi.

Xulosa: Dizayn Patternlari Bilan Yaxshiroq Dasturiy Ta'minot Yaratish

Biz uchta asosiy dizayn patterni — Singleton, Factory va Observer bo'ylab sayohat qildik va ularning Python'da umumiy arxitektura muammolarini hal qilish uchun qanday amalga oshirilishini ko'rdik.

• Singleton patterni bizga umumiy resurslarni boshqarish uchun mukammal bo'lgan yagona, global miqyosda foydalanish mumkin bo'lgan instansiyani beradi, lekin global holatning kamchiliklaridan qochish uchun ehtiyotkorlik bilan ishlatilishi kerak.
• Factory patternlari (Factory Method va Abstract Factory) obyekt yaratishni klient kodidan ajratishning kuchli usulini taqdim etadi, bu bizning tizimlarimizni yanada modulli va kengaytiriladigan qiladi.
• Observer patterni obyektlarga boshqa obyektlardagi holat o'zgarishlariga obuna bo'lish va reaksiya bildirish imkonini berib, kuchsiz bog'liqlikni rag'batlantirgan holda toza, hodisalarga asoslangan arxitekturani ta'minlaydi.

Dizayn patternlarini o'zlashtirishning kaliti ularning amaliyotlarini yodlash emas, balki ular hal qiladigan muammolarni tushunishdir. Dizayn muammosiga duch kelganingizda, ma'lum bir pattern mustahkam, oqilona va qo'llab-quvvatlanadigan yechimni taqdim eta oladimi yoki yo'qligi haqida o'ylang. Ushbu patternlarni dasturchi asboblar to'plamingizga integratsiya qilish orqali siz nafaqat funksional, balki toza, mustahkam va kelajakdagi o'sishga tayyor kod yozishingiz mumkin.